const express = require('express');
const fileUpload = require('express-fileupload');
const bodyParser = require('body-parser'); // 将这行提前到这里，保证在使用前已定义
const sqlite3 = require('sqlite3').verbose();
const bcrypt = require('bcrypt');
const path = require('path');
const fs = require('fs');
const http = require('http'); 
    
const app = express();
const port = 8080;

// 用于存储客户端对应的服务器当前目录，以客户端IP和端口作为标识
const clientDirectories = new Map();

// 挂载中间件，此时 body_parser 已经被正确定义，可以正常使用了
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(fileUpload());
app.use(authMiddleware);

// 连接SQLite3数据库
const db = new sqlite3.Database('fileManagement.db', (err) => {
    if (err) {
        console.error(err.message);
        return;
    }
    console.log('已连接到SQLite数据库。');
    // 创建用户表（如果不存在），包含用户名、加密后的密码、根路径字段
    db.run('CREATE TABLE IF NOT EXISTS users (username TEXT PRIMARY KEY, password_hash TEXT, root_path TEXT)', (err) => {
        if (err) {
            console.error(err.message);
        }
    });
 
    const testUsers = [
        { username: 'zs', password: 'ddd' },
        { username: 'ls', password: 'ddd' }
    ];
    testUsers.forEach(user => {
        bcrypt.hash(user.password, 10, (err, hash) => {
            if (err) {
                console.error(err.message);
                return;
            }
            db.run('INSERT OR IGNORE INTO users (username, password_hash, root_path) VALUES (?,?,?)', [user.username, hash, '/'], (err) => {
                if (err) {
                    console.error(err.message);
                }
                else {
                    console.log(`用户 ${user.username} 已成功插入到数据库。`); // 添加调试信息
                }
            });
        });
    });
     // 查询并打印所有用户
   db.all('SELECT * FROM users', [], (err, rows) => {
    if (err) {
        console.error(err.message);
    }
    console.log('当前数据库中的用户：', rows);
});
});

// 验证用户身份的中间件
function authMiddleware(req, res, next) {
    const { username, password } = req.headers;
    console.log(`接收到的用户名：${username}`); // 添加调试信息
    console.log(`接收到的密码：${password}`); 
    db.get('SELECT password_hash FROM users WHERE username = ?', [username], (err, row) => {
        if (err) return res.status(500).send('数据库查询错误');
        if (!row) return res.status(401).send('未授权：用户未找到');
        bcrypt.compare(password, row.password_hash, (err, result) => {
            if (err) return res.status(500).send('密码比对错误');
            if (!result) return res.status(401).send('未授权：密码错误');
            next();
        });
    });
}
app.post('/login', (req, res) => {
    const { username, password } = req.body;
    db.get('SELECT password_hash FROM users WHERE username = ?', [username], (err, row) => {
      if (err) return res.status(500).send('数据库查询错误');
      if (!row) return res.status(401).send('未授权：用户未找到');
      bcrypt.compare(password, row.password_hash, (err, result) => {
        if (err) return res.status(500).send('密码比对错误');
        if (result) {
          // 登录成功，可以设置session或者返回一个token
          res.send({ success: true, message: '登录成功' });
        } else {
          res.status(401).send('未授权：密码错误');
        }
      });
    });
  });

// 文件上传路由
app.post('/upload', (req, res) => {
    console.log('服务器收到的文件：', req.files); // 打印出中间件解���后的文件相关信息
    if (!req.files || Object.keys(req.files).length === 0) {
        console.log('没有文件被上传');
        return res.status(400).send('没有文件被上传');
    }
    const file = req.files.file; // 确保这里获取到文件
    console.log(`上传的文件名：${file.name}`); // 添加调试信息
    const { username } = req.headers;
    // 根据用户名获取根路径
    db.get('SELECT root_path FROM users WHERE username =?', [username], (err, row) => {
        if (err) {
            console.error('数据库查询错误：', err);
            return res.status(500).send('数据库查询错误');
        }
        const rootPath = row.root_path;
        const uploadPath = path.join(rootPath, file.name);
        file.mv(uploadPath, (err) => {
            if (err) {
                console.error('文件上传错误：', err);
                return res.status(500).send('文件上传错误');
            }
            console.log('文件上传成功');
            res.send('文件上传成功');
        });
    });
});

// 文件下载路由
app.get('/download', authMiddleware, (req, res) => {
    const { filename } = req.query;
    const { username } = req.headers;
  
    db.get('SELECT root_path FROM users WHERE username =?', [username], (err, row) => {
        if (err) return res.status(500).send('数据库查询错误');
        const rootPath = row.root_path;
        const filePath = path.join(rootPath, filename);
        res.download(filePath, (err) => {
            if (err) return res.status(500).send('文件下载错误');
        });
    });
});

// 文件删除路由
app.delete('/delete', authMiddleware, (req, res) => {
    const { filename } = req.query;
    const { username } = req.headers;

    // 根据用户名获取根路径
    db.get('SELECT root_path FROM users WHERE username =?', [username], (err, row) => {
        if (err) return res.status(500).send('数据库查询错误');
        const rootPath = row.root_path;
        const filePath = path.join(rootPath, filename); // 构建完整的文件路径

        // 检查文件是否存在
        fs.access(filePath, fs.constants.F_OK, (err) => {
            if (err) {
                console.error('文件不存在：', filePath);
                return res.status(404).send('文件不存在');
            }

            // 删除文件
            fs.unlink(filePath, (err) => {
                if (err) {
                    console.error('文件删除错误：', err);
                    return res.status(500).send('文件删除错误');
                }
                console.log('文件删���成功');
                res.send('文件删除成功');
            });
        });
    });
});

// 文件重命名路由
app.put('/rename', authMiddleware, (req, res) => {
    const { oldFilename, newFilename } = req.query;
    const { username } = req.headers;
    // 根据用户名获取根路径
    db.get('SELECT root_path FROM users WHERE username =?', [username], (err, row) => {
        if (err) return res.status(500).send('数据库查询错误');
        const rootPath = row.root_path;
        const oldFilePath = path.join(rootPath, oldFilename);
        const newFilePath = path.join(rootPath, newFilename);
        fs.rename(oldFilePath, newFilePath, (err) => {
            if (err) return res.status(500).send('文件重命名错误');
            res.send('文件重命名成功');
        });
    });
});

// 件夹创建路由
app.post('/mkdir', authMiddleware, (req, res) => {
    const { dirname } = req.query;
    console.log(`尝试创建文件夹：${dirname}`); // 添加调试信息
    const { username } = req.headers;
    db.get('SELECT root_path FROM users WHERE username =?', [username], (err, row) => {
        if (err) {
            console.error('数据库查询错误：', err);
            return res.status(500).send(JSON.stringify({ message: '数据库查询错误' }));
        }
        const rootPath = row.root_path;
        const dirPath = path.join(rootPath, dirname);
        fs.mkdir(dirPath, { recursive: true }, (err) => {
            if (err) {
                console.error('文件夹创建错误：', err);
                return res.status(500).send(JSON.stringify({ message: '文件夹创建错误' }));
            }
            console.log('文件夹创建成功');
            res.send(JSON.stringify({ message: '文件夹创建成功' }));
        });
    });
}
 );

// 文件夹删除路由
app.delete('/deleteDir', authMiddleware, (req, res) => {
    const { dirname } = req.query;
    const { username } = req.headers;
    // 根据用户名获取根路径
    db.get('SELECT root_path FROM users WHERE username =?', [username], (err, row) => {
        if (err) return res.status(500).send('数据库查询错误');
        const rootPath = row.root_path;
        const dirPath = path.join(rootPath, dirname);
        fs.rmdir(dirPath, { recursive: true }, (err) => {
            if (err) return res.status(500).send('文件夹删除错误');
            res.send('文件夹删除成功');
        });
    });
});

// 文件夹重命名路由
app.put('/renameDir', authMiddleware, (req, res) => {
    const { oldDirname, newDirname } = req.query;
    const { username } = req.headers;
    // 根据用户名获取根路径
    db.get('SELECT root_path FROM users WHERE username =?', [username], (err, row) => {
        if (err) return res.status(500).send('数据库查询错误');
        const rootPath = row.root_path;
        const oldDirPath = path.join(rootPath, oldDirname);
        const newDirPath = path.join(rootPath, newDirname);
        fs.rename(oldDirPath, newDirPath, (err) => {
            if (err) return res.status(500).send('文件夹重命名错误');
            res.send('文件夹重命名成功');
        });
    });
});

// 查看目录内容路由
app.get('/list', authMiddleware, (req, res) => {
    const { username } = req.headers;
    // 根据用户名获取根路径
    db.get('SELECT root_path FROM users WHERE username =?', [username], (err, row) => {
        if (err) return res.status(500).send('数据库查询错误');
        const rootPath = row.root_path;
        console.log(`根路径：${rootPath}`); 
        fs.readdir(rootPath, (err, files) => {
            if (err) {
                console.error('读取目录错误：', err);
                return res.status(500).send('读取目录错误');
            }
            const fileList = files.map(file => {
                const filePath = path.join(rootPath, file);
                const stats = fs.statSync(filePath);
                return {
                    name: file,
                    type: stats.isDirectory() ? 'directory' : 'file'
                };
            });
            res.send(fileList);
        });
    });
});

// 修改服务器当前目录路由
app.post('/rcd', authMiddleware, (req, res) => {
    const { dirname } = req.query;
    const clientId = req.socket.remoteAddress + req.socket.remotePort;
    clientDirectories.set(clientId, dirname);
    res.send('Server current directory updated successfully');
});

// 获取服务器当前目录路由
app.get('/rpwd', authMiddleware, (req, res) => {
    const clientId = req.socket.remoteAddress + req.socket.remotePort;
    const currentDir = clientDirectories.get(clientId) || '/';
    res.send({ path: currentDir });
});

app.listen(port, () => {
    console.log(`Server running on port ${port}`);
});